home *** CD-ROM | disk | FTP | other *** search
/ No Fragments Archive 12: Textmags & Docs / nf_archive_12.iso / MAGS / SOURCES / ATARI_SRC.ZIP / atari source / HDX_BACK / HDX503 / FMT.C < prev    next >
Encoding:
C/C++ Source or Header  |  2001-02-09  |  9.4 KB  |  444 lines
  1. /* fmt.c */
  2.  
  3. #include "obdefs.h"
  4. #include "osbind.h"
  5. #include "mydefs.h"
  6. #include "part.h"
  7. #include "hdx.h"
  8. #include "addr.h"
  9. #include "myerror.h"
  10.  
  11. #define MFM 17            /* sectors per track of MFM */
  12. #define RLL 26            /* sectors per track of RLL */
  13.  
  14. extern long ostack;
  15. extern int typedev;
  16. extern int typedrv;
  17. extern char sbuf[];
  18.  
  19. /*
  20.  * These constants are used in a heuristic that determines
  21.  * if the format parameter information in the boot sector
  22.  * is intact.  (See fmtpok()).
  23.  */
  24. #define    MAXCYLS        4096        /* max number of cylinders */
  25. #define    MINCYLS        100        /* minimum number of cylinders */
  26. #define    MAXHEADS    16        /* max number of heads */
  27. #define    MINHEADS    2        /* minimum number of heads */
  28. #define    MAXLZ        16        /* max landing zone value */
  29. #define    MAXRT        2        /* max step-rate code */
  30.  
  31.  
  32. /*
  33.  * These are the default format parameters;
  34.  * they are for a 20Mb Mutsubuishi drive.
  35.  *
  36.  * @ If we change drives, this might have to be changed.
  37.  *
  38.  */
  39. HINFO deffmt = {
  40.     0x264,        /* 612 cylinders */
  41.     4,            /* 4 heads */
  42.     0x264,        /* no reduced write-current cylinder */
  43.     0x264,        /* no write precomp cylinder */
  44.     10,            /* landing zone position = 10 */
  45.     2,            /* 2 use buffered seeks */
  46.     1,            /* 2 interleave = 1 */
  47.     17            /* 17 sectors per track */
  48. };
  49.  
  50.  
  51. /*
  52.  * Report format error.
  53.  *
  54.  */
  55. formaterr(dev)
  56. int dev;
  57. {
  58.     char *pdev="X";
  59.     
  60.     if (dev > 15)
  61.         dev -= 16;
  62.     else if (dev > 7) 
  63.         dev -= 8;
  64.     *pdev = dev + '0';
  65.     (cantform[FMTDEV].ob_spec)->te_ptext = pdev;
  66.     cantform[FMTERROK].ob_state = NORMAL;
  67.     execform(cantform);
  68.     return ERROR;
  69. }
  70.  
  71.  
  72. /*
  73.  * Set format parameters in a
  74.  * root sector image.
  75.  * 6-13-88  only set size of hard disk.
  76.  *
  77.  */
  78.  
  79. sdisksiz(image, hdsiz)
  80. char *image;
  81. long hdsiz;
  82. {
  83.     ((RSECT *)(image + 0x200 - sizeof(RSECT)))->hd_siz = hdsiz;
  84.  
  85. }
  86.  
  87.  
  88. /*
  89.  * Set format parameters in a
  90.  * root sector image.
  91.  *
  92.  */
  93. sfmtparm(image, fmtparm)
  94. char *image;
  95. HINFO *fmtparm;
  96. {
  97.     register HINFO *rinfo;
  98.     register long siz;
  99.  
  100.     rinfo = &((RSECT *)(image + 0x200 - sizeof(RSECT)))->hd_info;
  101.     rinfo->hi_cc = fmtparm->hi_cc;
  102.     rinfo->hi_dhc = fmtparm->hi_dhc;
  103.     rinfo->hi_rwcc = fmtparm->hi_rwcc;
  104.     rinfo->hi_wpc = fmtparm->hi_wpc;
  105.     rinfo->hi_lz = fmtparm->hi_lz;
  106.     rinfo->hi_rt = fmtparm->hi_rt;
  107.     rinfo->hi_in = fmtparm->hi_in;
  108.     rinfo->hi_spt = fmtparm->hi_spt;
  109.  
  110.     /* Compute total disk size
  111.      * = <#cyls> * <#heads> * <#sectors / track>
  112.      */
  113.     ((RSECT *)(image + 0x200 - sizeof(RSECT)))->hd_siz = 
  114.         (long)fmtparm->hi_cc *
  115.         (long)fmtparm->hi_dhc *
  116.         (long)fmtparm->hi_spt; 
  117.  
  118. }
  119.  
  120.  
  121. /*
  122.  * Determine if format parameters are good;
  123.  * return OK if they appear to be,
  124.  * ERROR if they don't appear to be.
  125.  *
  126.  */
  127. fmtpok(fmtparm)
  128. HINFO *fmtparm;
  129. {
  130.     if (fmtparm->hi_cc > MAXCYLS ||
  131.     fmtparm->hi_cc < MINCYLS ||
  132.     fmtparm->hi_dhc > MAXHEADS ||
  133.     fmtparm->hi_dhc < MINHEADS ||
  134.     fmtparm->hi_lz > MAXLZ ||
  135.     fmtparm->hi_rt > MAXRT)
  136.         return ERROR;
  137.  
  138.     return OK;
  139. }
  140.  
  141.  
  142. /*
  143.  * Setup default format parameters in hinfo;
  144.  * (REAL C compilers do this with a structure assignment...)
  145.  *
  146.  */
  147. fdefault(hinfop)
  148. HINFO *hinfop;
  149. {
  150.     hinfop->hi_cc = deffmt.hi_cc;
  151.     hinfop->hi_dhc = deffmt.hi_dhc;
  152.     hinfop->hi_rwcc = deffmt.hi_rwcc;
  153.     hinfop->hi_wpc = deffmt.hi_wpc;
  154.     hinfop->hi_lz = deffmt.hi_lz;
  155.     hinfop->hi_rt = deffmt.hi_rt;
  156.     hinfop->hi_in = deffmt.hi_in;
  157.     hinfop->hi_spt = deffmt.hi_spt;
  158. }
  159.  
  160.  
  161. /*
  162.  * Set mode information on drive.
  163.  *
  164.  */
  165. ms(dev, hinfo)
  166. int dev;
  167. HINFO *hinfo;
  168. {
  169.     int i;
  170.     char *p;
  171.     SETMODE mb;
  172.     extern long mdselect();
  173.  
  174.     /* initialize parameter structure */
  175.     p = (char *)&mb;
  176.     for (i = sizeof(SETMODE); i--;)
  177.     *p++ = 0;
  178.     mb.smd_8 = 0x08;
  179.     mb.smd_1 = 0x01;
  180.     mb.smd_bs[1] = 0x02;    /* block size = 512 */
  181.  
  182.     cpw(&mb.smd_cc[0], hinfo->hi_cc);
  183.     mb.smd_dhc = hinfo->hi_dhc;
  184.     cpw(&mb.smd_rwc[0], hinfo->hi_rwcc);
  185.     cpw(&mb.smd_wpc[0], hinfo->hi_wpc);
  186.     mb.smd_lz = hinfo->hi_lz;
  187.     mb.smd_rt = hinfo->hi_rt;
  188.  
  189.     return (int)mdselect(dev, 22, &mb);
  190. }
  191.  
  192.  
  193. /*
  194.  * Move `w' to unaligned location.
  195.  *
  196.  */
  197. cpw(d, w)
  198. char *d;
  199. WORD w;
  200. {
  201.     char *s;
  202.  
  203.     s = (char *)&w;
  204.     d[0] = s[0];
  205.     d[1] = s[1];
  206. }
  207.  
  208.  
  209. /*
  210.  * Return format parameters in `hinfo', based on
  211.  * the format parameter name `fpnam'.
  212.  *
  213.  * return 0 on OK,
  214.  * -1 on [CANCEL].
  215.  *
  216.  */
  217. gfparm(dev, noinfo, modesel, hinfop, fpnam, id)
  218. int dev;
  219. int *noinfo;            /* 1: no information inside the wincap file */
  220. int *modesel;
  221. HINFO *hinfop;
  222. char *fpnam, *id;
  223. {
  224.     long num;
  225.     char name[128];
  226.     int mask=0x0001;
  227.     int scsidrv, set, ret = OK;
  228.     UWORD cyl; 
  229.     BYTE nhead, sptrk;
  230.  
  231.     set = typedev & (mask << dev);
  232.     scsidrv = typedrv & (mask << dev);
  233.     fdefault(hinfop);
  234. jjj:
  235.      if (*noinfo)    { /* no information in wincap */
  236.         if ((set) || (scsidrv) || (dev > 15))        {
  237.             *modesel = 0;
  238.             return (ret);
  239.         }
  240.         ret = cyhdsp(dev, &cyl, &nhead, &sptrk);
  241.         hinfop->hi_cc = cyl;
  242.         hinfop->hi_dhc = nhead;
  243.         hinfop->hi_rwcc = cyl;
  244.         hinfop->hi_wpc =  cyl;
  245.         hinfop->hi_spt =  sptrk;
  246.     } else {
  247.  
  248.         strcpy(name, fpnam);
  249.         if (wgetent(fpnam, id) == ERROR) {
  250.             *noinfo = 1;
  251.             goto jjj;
  252.             /*
  253.             nofmt[NOSCHFOK].ob_state = NORMAL;
  254.             (nofmt[NOSCHFMT].ob_spec)->te_ptext = name;
  255.             execform(nofmt);
  256.             return ERROR;
  257.             */
  258.         }
  259.         if ((set) || (scsidrv) || (dev > 15))        {
  260.             hinfop->hi_cc = 0;
  261.             hinfop->hi_dhc = 0;
  262.             hinfop->hi_spt =  0;
  263.         }
  264.         if (wgetnum("cy", &num) == OK) hinfop->hi_cc = (UWORD)num;
  265.         if (wgetnum("hd", &num) == OK) hinfop->hi_dhc = (BYTE)num;
  266.         if (wgetnum("rw", &num) == OK) hinfop->hi_rwcc = (UWORD)num;
  267.         if (wgetnum("wp", &num) == OK) hinfop->hi_wpc = (UWORD)num;
  268.         if (wgetnum("lz", &num) == OK) hinfop->hi_lz = (BYTE)num;
  269.         if (wgetnum("rt", &num) == OK) hinfop->hi_rt = (BYTE)num;
  270.         if (wgetnum("in", &num) == OK) hinfop->hi_in = (BYTE)num;
  271.         if (wgetnum("sp", &num) == OK) hinfop->hi_spt = (BYTE)num;
  272.         if (wgetnum("md", &num) == OK) *modesel = (UWORD)num;
  273.         if ((set) || (scsidrv) || (dev > 15))        
  274.             if((!hinfop->hi_cc)||(!hinfop->hi_dhc)||(!hinfop->hi_spt))    {
  275.                 *noinfo = 1;
  276.                 *modesel = 0;
  277.             }
  278.     }
  279.     return(ret);
  280. }
  281.  
  282.  
  283. /*
  284.  *    Set mode information on a SYQUEST drive.
  285.  *
  286.  */
  287.  
  288. sqms(dev, sendata)
  289. int dev;            /* physical device number */
  290. char sendata[];
  291. {
  292.     extern long mdselect();
  293.     char buf[32];
  294.  
  295.     inquiry(dev, (WORD)16, buf);
  296.     if (buf[8] == 'Q' & buf[9] == 'U' & buf[10] == 'A' & buf[11] == 'N') 
  297.         /* It is a QUANTUM hard disk. So don't need to set the page one. */
  298.         return OK;
  299.     sendata[0] = sendata[2] = 0;    /* reserved */
  300.     sendata[3] = 0x08;                /* block descriptor length */
  301.     sendata[12] = 0;                /* Reserved = 0; Page Code = 0 */
  302.     sendata[13] = 0x02;                
  303.     sendata[14] = 0x10;                /* set inhst bit in page 00 */
  304.     sendata[15] = 0;                /* Device type qualifier  */
  305.     return (int)mdselect(dev, 16, sendata);
  306. }
  307.  
  308.  
  309.  
  310.  
  311. /* 
  312.  * get cylinder, # of head, and sector per track for ST
  313.  */
  314.  
  315. cyhdsp(dev, cyl, head, spt)
  316.  
  317. int dev;
  318. UWORD *cyl; 
  319. BYTE *head, *spt;
  320.  
  321. {
  322.     char *num;
  323.     BYTE sptrk,numhead;
  324.     int i, ret, totcyl, numtrack;
  325.     extern long get3bytes();
  326.     SETMODE *mb;
  327.     SECTOR size, msiz;    /* size of media */
  328.     char buf[512], sendata[32];
  329.     long dmaptr, tmpptr, spcyl;
  330.     char *dmahigh=0xffff8609,
  331.          *dmamid=0xffff860b,
  332.          *dmalow=0xffff860d;
  333.  
  334.     /*
  335.     ostack = Super(NULL);
  336.     delay();
  337.     for (i = 0; i < 32; i++)
  338.         sendata[i] = 0;
  339.     if (mdsense(dev, 3, 0, 32, sendata) == OK)    {
  340.         for (i=0; i<32; i++)    {
  341.             if (sendata[i])
  342.                 break;
  343.         }
  344.         if (i == 32)    {     no info return in the buf 'sendata' 
  345.             goto dopg0;
  346.         }
  347.         if (!(*spt = getword(sendata+22)))    
  348.             goto dopg0;
  349.         if (mdsense(dev, 4, 0, 22, sendata) == OK)    {
  350.             for (i=0; i<22; i++)    {
  351.                 if (sendata[i])
  352.                     break;
  353.             }
  354.             if (i == 22)    {    no info return in the buf 'sendata' 
  355.                 goto dopg0;
  356.             }
  357.             if (!(*cyl = get3bytes(sendata+14)))
  358.                 goto dopg0;
  359.             if (!(*head = *(sendata+17)))
  360.                 goto dopg0;
  361.             delay();
  362.             Super(ostack);
  363.             return OK;
  364.         } 
  365.     } 
  366.  
  367. dopg0:
  368. */
  369.     ostack = Super(NULL);
  370.     delay();
  371.     for (i = 0; i < 22; i++)
  372.         sendata[i] = 0;
  373.     /* get format parameters/ disk size from emdia */
  374.     ret = mdsense(dev, 0, 0, 22, sendata);
  375.     delay();
  376.     Super(ostack);
  377.     if (ret != OK)     {
  378.         return (formaterr(dev));
  379.     }
  380.     for (i=0; i<22; i++)    {
  381.         if (sendata[i])
  382.             break;
  383.     }
  384.     if (i == 22)    {    /* no info return in the buf 'sendata' */
  385.         err(needinfo);
  386.         return ERROR;
  387.     }
  388.  
  389.       mb = (SETMODE *)sendata;
  390.     /* get number of cylinders */
  391.     totcyl = mb->smd_cc[0];
  392.     totcyl <<= 8;
  393.     totcyl |= mb->smd_cc[1];
  394.     *cyl = (UWORD)totcyl;
  395.  
  396.     /* get number of heads */
  397.     numhead = mb->smd_dhc;
  398.     *head = numhead;
  399.   
  400.     sptrk = (long)MFM;
  401.     msiz = (SECTOR)numhead * (SECTOR)totcyl * sptrk;
  402.   
  403.     for (i = 0; i < 20; i++) {
  404.         if ((ret = rdsects(dev, 1, buf, msiz+i)) == OK) {
  405.  
  406.         /* find out whether data has been transferred, by
  407.               checking if dma pointer has been moved.      */
  408.  
  409.             ostack = Super(NULL);
  410.             delay();
  411.             dmaptr = *dmahigh;
  412.             dmaptr &= 0x0000003f;
  413.             dmaptr <<= 16;
  414.             tmpptr = *dmamid;
  415.             tmpptr &= 0x000000ff;
  416.             tmpptr <<= 8;
  417.             dmaptr |= tmpptr;
  418.             tmpptr = *dmalow;
  419.             tmpptr &= 0x000000ff;
  420.             dmaptr |= tmpptr;
  421.             delay();
  422.             Super(ostack);
  423.  
  424.             if (dmaptr != buf)
  425.                 break;
  426.            } else {            /* rdsects return an error */
  427.             if (tsterr(ret) == OK) {
  428.                     break;
  429.             }
  430.            }
  431.     }
  432.  
  433.     /* Determine if media is MFM or RLL */
  434.     if (i < 20)        {
  435.         *spt = RLL;
  436.     } else {
  437.         *spt = MFM;
  438.     }
  439.     return OK;
  440. }
  441.  
  442.  
  443.  
  444.